package example;

import java.util.concurrent.locks.ReentrantLock;

/**
 * ReentrantLock类是一种可重入的互斥锁
 *
 *
 *
 * @author DengZhiYuan
 * @version 1.0
 * @date 2023/3/12 11:04
 */
public class ReentrantLockDemo {
//    lock()：获取锁。
//    unlock()：释放锁。
//    tryLock()：尝试获取锁，如果锁可用则获取锁并立即返回 true，否则立即返回 false。
//    tryLock(long timeout, TimeUnit unit)：尝试获取锁，在给定的时间内如果锁可用则获取锁并立即返回 true，否则等待直到超时，并返回 false。
//    getHoldCount()：查询当前线程保持此锁的次数。
//    isHeldByCurrentThread()：查询此锁是否由当前线程保持。
//    getQueueLength()：查询等待获取此锁的线程数。
//    isLocked()：查询此锁是否被任何线程保持。
//    newCondition()：返回绑定到此 Lock 实例的新 Condition 实例。

    private final ReentrantLock lock = new ReentrantLock();

    private int count = 0;

    public void increment(){
        lock.lock(); // Acquire the lock
        try {
            count++; // Perform some critical section operations
        } finally {
            lock.unlock(); // Release the lock
        }
    }

    public int getCount(){
        lock.lock(); // Acquire the lock
        try {
            return count; // Return the value of the count variable
        } finally {
            lock.unlock(); // Release the lock
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockDemo demo = new ReentrantLockDemo();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                demo.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                demo.increment();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(demo.getCount()); // Should output 20000
    }


}
